/**
 * 审核结果通知工具
 * 用于检查和显示用户的审核驳回通知
 */

import api from './api.js'

export const NotificationUtils = {
  /**
   * 检查用户的审核结果通知
   * 在用户登录后或进入首页时调用
   */
  async checkAuditResults() {
    try {
      console.log('🔍 开始检查审核结果通知...')
      
      // 获取用户信息，包含审核结果
      const response = await api.getUserInfo()
      
      console.log('📡 用户信息API响应:', {
        success: response.success,
        hasUnreadAuditResults: response.data?.hasUnreadAuditResults,
        auditResultsCount: response.data?.auditResults?.length || 0,
        auditResults: response.data?.auditResults
      })
      
      if (response.success && response.data.hasUnreadAuditResults) {
        const auditResults = response.data.auditResults
        
        if (auditResults && auditResults.length > 0) {
          // 检查本地存储，避免重复提示
          const shouldShow = this.shouldShowNotification(auditResults)
          
          if (shouldShow.length > 0) {
            // 显示审核结果通知
            this.showAuditResultNotifications(shouldShow)
            
            // 标记为已查看
            this.markNotificationsAsViewed(shouldShow)
          }
        }
      }
    } catch (error) {
      console.log('检查审核结果失败:', error)
    }
  },

  /**
   * 检查哪些通知需要显示（避免重复提示）
   * @param {Array} auditResults 审核结果列表
   * @returns {Array} 需要显示的通知列表
   */
  shouldShowNotification(auditResults) {
    try {
      // 检查uni是否可用
      if (typeof uni === 'undefined') {
        console.log('⚠️ uni对象不可用，返回所有通知')
        return auditResults
      }

      // 从本地存储获取已查看的通知ID列表
      const viewedNotifications = uni.getStorageSync('viewedAuditNotifications') || []
      
      // 过滤出未查看的通知
      return auditResults.filter(result => {
        const notificationId = `${result.type}_${result.id}_${result.time}`
        return !viewedNotifications.includes(notificationId)
      })
    } catch (error) {
      console.log('检查通知显示状态失败:', error)
      return auditResults // 出错时显示所有通知
    }
  },

  /**
   * 显示审核结果通知弹窗
   * @param {Array} auditResults 审核结果列表
   */
  showAuditResultNotifications(auditResults) {
    // 逐个显示通知，避免同时弹出多个modal
    this.showNotificationSequentially(auditResults, 0)
  },

  /**
   * 顺序显示通知
   * @param {Array} auditResults 审核结果列表
   * @param {number} index 当前显示的索引
   */
  showNotificationSequentially(auditResults, index) {
    if (index >= auditResults.length) {
      return // 所有通知都已显示完毕
    }

    // 检查uni是否可用
    if (typeof uni === 'undefined') {
      console.log('⚠️ uni对象不可用，无法显示通知')
      return
    }

    const result = auditResults[index]
    const typeName = result.type === 'listing' ? '挂牌信息' : '本地服务'
    
    uni.showModal({
      title: '审核结果通知',
      content: `您的${typeName}"${result.name}"审核未通过。\n\n驳回原因：${result.comment}\n\n请修改后重新提交。`,
      showCancel: true,
      cancelText: '知道了',
      confirmText: '去修改',
      success: (res) => {
        if (res.confirm) {
          // 用户点击"去修改"，跳转到对应的编辑页面
          this.navigateToEdit(result)
        }
        
        // 继续显示下一个通知
        this.showNotificationSequentially(auditResults, index + 1)
      },
      fail: () => {
        // 即使显示失败也要继续下一个
        this.showNotificationSequentially(auditResults, index + 1)
      }
    })
  },

  /**
   * 跳转到对应的编辑页面
   * @param {Object} result 审核结果对象
   */
  navigateToEdit(result) {
    try {
      // 检查uni是否可用
      if (typeof uni === 'undefined') {
        console.log('⚠️ uni对象不可用，无法跳转页面')
        return
      }

      if (result.type === 'listing') {
        // 跳转到挂牌信息编辑页面
        uni.navigateTo({
          url: `/pages/listings/edit?id=${result.id}`
        })
      } else if (result.type === 'service') {
        // 跳转到本地服务编辑页面
        uni.navigateTo({
          url: `/pages/local-services/edit?id=${result.id}`
        })
      }
    } catch (error) {
      console.log('跳转编辑页面失败:', error)
      if (typeof uni !== 'undefined') {
        uni.showToast({
          title: '跳转失败',
          icon: 'none'
        })
      }
    }
  },

  /**
   * 标记通知为已查看
   * @param {Array} auditResults 审核结果列表
   */
  markNotificationsAsViewed(auditResults) {
    try {
      // 检查uni是否可用
      if (typeof uni === 'undefined') {
        console.log('⚠️ uni对象不可用，无法标记通知')
        return
      }

      // 获取当前已查看的通知列表
      const viewedNotifications = uni.getStorageSync('viewedAuditNotifications') || []
      
      // 添加新查看的通知ID
      const newViewedIds = auditResults.map(result => {
        return `${result.type}_${result.id}_${result.time}`
      })
      
      const updatedViewedNotifications = [...viewedNotifications, ...newViewedIds]
      
      // 只保留最近100个已查看记录，避免本地存储过大
      const limitedNotifications = updatedViewedNotifications.slice(-100)
      
      // 存储到本地
      uni.setStorageSync('viewedAuditNotifications', limitedNotifications)
      
      // 可选：调用后端API标记为已查看（当前后端API已实现但不是必需的）
      // this.markViewedOnServer(auditResults)
      
    } catch (error) {
      console.log('标记通知已查看失败:', error)
    }
  },

  /**
   * 在服务器端标记为已查看（可选）
   * @param {Array} auditResults 审核结果列表
   */
  async markViewedOnServer(auditResults) {
    try {
      for (const result of auditResults) {
        await api.markAuditViewed(result.type, result.id)
      }
    } catch (error) {
      console.log('服务器端标记失败:', error)
    }
  },

  /**
   * 清理过期的本地通知记录
   * 可以在应用启动时调用
   */
  cleanupExpiredNotifications() {
    try {
      // 检查uni是否可用
      if (typeof uni === 'undefined') {
        console.log('⚠️ uni对象不可用，无法清理过期通知')
        return
      }

      // 清理超过7天的本地通知记录
      // 这是一个简单的清理策略
      const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000
      
      // 获取所有已查看的通知
      const viewedNotifications = uni.getStorageSync('viewedAuditNotifications') || []
      
      // 过滤掉过期的记录（这需要改进通知ID格式以包含时间戳）
      // 当前实现中，我们简单地限制数量而不是按时间清理
      
      if (viewedNotifications.length > 200) {
        // 只保留最新的100个记录
        const recentNotifications = viewedNotifications.slice(-100)
        uni.setStorageSync('viewedAuditNotifications', recentNotifications)
      }
      
    } catch (error) {
      console.log('清理过期通知记录失败:', error)
    }
  }
}

export default NotificationUtils